home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_binascii.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  5.6 KB  |  188 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Test the binascii C module.'''
  5. from test import test_support
  6. import unittest
  7. import binascii
  8.  
  9. class BinASCIITest(unittest.TestCase):
  10.     data = 'The quick brown fox jumps over the lazy dog.\r\n'
  11.     data += ''.join(map(chr, xrange(256)))
  12.     data += '\r\nHello world.\n'
  13.     
  14.     def test_exceptions(self):
  15.         self.assert_(issubclass(binascii.Error, Exception))
  16.         self.assert_(issubclass(binascii.Incomplete, Exception))
  17.  
  18.     
  19.     def test_functions(self):
  20.         funcs = []
  21.         for suffix in ('base64', 'hqx', 'uu', 'hex'):
  22.             prefixes = [
  23.                 'a2b_',
  24.                 'b2a_']
  25.             if suffix == 'hqx':
  26.                 prefixes.extend([
  27.                     'crc_',
  28.                     'rlecode_',
  29.                     'rledecode_'])
  30.             
  31.             for prefix in prefixes:
  32.                 name = prefix + suffix
  33.                 self.assert_(callable(getattr(binascii, name)))
  34.                 self.assertRaises(TypeError, getattr(binascii, name))
  35.             
  36.         
  37.         for name in ('hexlify', 'unhexlify'):
  38.             self.assert_(callable(getattr(binascii, name)))
  39.             self.assertRaises(TypeError, getattr(binascii, name))
  40.         
  41.  
  42.     
  43.     def test_base64valid(self):
  44.         MAX_BASE64 = 57
  45.         lines = []
  46.         for i in range(0, len(self.data), MAX_BASE64):
  47.             b = self.data[i:i + MAX_BASE64]
  48.             a = binascii.b2a_base64(b)
  49.             lines.append(a)
  50.         
  51.         res = ''
  52.         for line in lines:
  53.             b = binascii.a2b_base64(line)
  54.             res = res + b
  55.         
  56.         self.assertEqual(res, self.data)
  57.  
  58.     
  59.     def test_base64invalid(self):
  60.         MAX_BASE64 = 57
  61.         lines = []
  62.         for i in range(0, len(self.data), MAX_BASE64):
  63.             b = self.data[i:i + MAX_BASE64]
  64.             a = binascii.b2a_base64(b)
  65.             lines.append(a)
  66.         
  67.         fillers = ''
  68.         valid = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/'
  69.         for i in xrange(256):
  70.             c = chr(i)
  71.             if c not in valid:
  72.                 fillers += c
  73.                 continue
  74.         
  75.         
  76.         def addnoise(line):
  77.             noise = fillers
  78.             ratio = len(line) // len(noise)
  79.             res = ''
  80.             while line and noise:
  81.                 if len(line) // len(noise) > ratio:
  82.                     c = line[0]
  83.                     line = line[1:]
  84.                 else:
  85.                     c = noise[0]
  86.                     noise = noise[1:]
  87.                 res += c
  88.             return res + noise + line
  89.  
  90.         res = ''
  91.         for line in map(addnoise, lines):
  92.             b = binascii.a2b_base64(line)
  93.             res += b
  94.         
  95.         self.assertEqual(res, self.data)
  96.         self.assertEqual(binascii.a2b_base64(fillers), '')
  97.  
  98.     
  99.     def test_uu(self):
  100.         MAX_UU = 45
  101.         lines = []
  102.         for i in range(0, len(self.data), MAX_UU):
  103.             b = self.data[i:i + MAX_UU]
  104.             a = binascii.b2a_uu(b)
  105.             lines.append(a)
  106.         
  107.         res = ''
  108.         for line in lines:
  109.             b = binascii.a2b_uu(line)
  110.             res += b
  111.         
  112.         self.assertEqual(res, self.data)
  113.         self.assertEqual(binascii.a2b_uu('\x7f'), '\x00' * 31)
  114.         self.assertEqual(binascii.a2b_uu('\x80'), '\x00' * 32)
  115.         self.assertEqual(binascii.a2b_uu('\xff'), '\x00' * 31)
  116.         self.assertRaises(binascii.Error, binascii.a2b_uu, '\xff\x00')
  117.         self.assertRaises(binascii.Error, binascii.a2b_uu, '!!!!')
  118.         self.assertRaises(binascii.Error, binascii.b2a_uu, 46 * '!')
  119.  
  120.     
  121.     def test_crc32(self):
  122.         crc = binascii.crc32('Test the CRC-32 of')
  123.         crc = binascii.crc32(' this string.', crc)
  124.         self.assertEqual(crc, 1571220330)
  125.         self.assertRaises(TypeError, binascii.crc32)
  126.  
  127.     
  128.     def test_hex(self):
  129.         s = '{s\x05\x00\x00\x00worldi\x02\x00\x00\x00s\x05\x00\x00\x00helloi\x01\x00\x00\x000'
  130.         t = binascii.b2a_hex(s)
  131.         u = binascii.a2b_hex(t)
  132.         self.assertEqual(s, u)
  133.         self.assertRaises(TypeError, binascii.a2b_hex, t[:-1])
  134.         self.assertRaises(TypeError, binascii.a2b_hex, t[:-1] + 'q')
  135.         if test_support.have_unicode:
  136.             self.assertEqual(binascii.hexlify(unicode('a', 'ascii')), '61')
  137.         
  138.  
  139.     
  140.     def test_qp(self):
  141.         
  142.         try:
  143.             binascii.a2b_qp('', **{
  144.                 1: 1 })
  145.         except TypeError:
  146.             pass
  147.  
  148.         self.fail("binascii.a2b_qp(**{1:1}) didn't raise TypeError")
  149.         self.assertEqual(binascii.a2b_qp('= '), '')
  150.         self.assertEqual(binascii.a2b_qp('=='), '=')
  151.         self.assertEqual(binascii.a2b_qp('=AX'), '=AX')
  152.         self.assertRaises(TypeError, binascii.b2a_qp, foo = 'bar')
  153.         self.assertEqual(binascii.a2b_qp('=00\r\n=00'), '\x00\r\n\x00')
  154.         self.assertEqual(binascii.b2a_qp('\xff\r\n\xff\n\xff'), '=FF\r\n=FF\r\n=FF')
  155.         self.assertEqual(binascii.b2a_qp('0' * 75 + '\xff\r\n\xff\r\n\xff'), '0' * 75 + '=\r\n=FF\r\n=FF\r\n=FF')
  156.  
  157.     
  158.     def test_empty_string(self):
  159.         for n in [
  160.             'b2a_qp',
  161.             'a2b_hex',
  162.             'b2a_base64',
  163.             'a2b_uu',
  164.             'a2b_qp',
  165.             'b2a_hex',
  166.             'unhexlify',
  167.             'hexlify',
  168.             'crc32',
  169.             'b2a_hqx',
  170.             'a2b_hqx',
  171.             'a2b_base64',
  172.             'rlecode_hqx',
  173.             'b2a_uu',
  174.             'rledecode_hqx']:
  175.             f = getattr(binascii, n)
  176.             f('')
  177.         
  178.         binascii.crc_hqx('', 0)
  179.  
  180.  
  181.  
  182. def test_main():
  183.     test_support.run_unittest(BinASCIITest)
  184.  
  185. if __name__ == '__main__':
  186.     test_main()
  187.  
  188.